弹力设计篇之"降级设计" - [2026重制版]

resilience4j:
  circuitbreaker:
    instances:
      recommendationService:
        slidingWindowType: COUNT_BASED
        slidingWindowSize: 10
        failureRateThreshold: 60          # 失败率60%就熔断
        waitDurationInOpenState: 30s      # 熔断30秒
        
      inventoryService:
        slidingWindowType: TIME_BASED
        slidingWindowSize: 20s
        slowCallRateThreshold: 80         # 慢调用80%就熔断
        slowCallDurationThreshold: 2000ms # >2s算慢调用

@Service
@RequiredArgsConstructor
@Slf4j
public class ProductDetailService {
 
    private final RecommendationClient recommendationClient;
    private final InventoryClient inventoryClient;
    private final CacheManager cacheManager;  // Spring Cache
 
    /**
     * 商品详情页：组合多个服务的降级示例
     */
    public ProductDetailResponse getProductDetail(String productId) {
        // 1. 获取基础商品信息（必须成功，否则整个请求失败）
        ProductInfo productInfo = getBaseProductInfo(productId);
        
        // 2. 获取推荐列表（可降级）
        List<Recommendation> recommendations = getRecommendationsWithFallback(productId);
        
        // 3. 获取实时库存（可降级为缓存值）
        InventoryStatus inventory = getInventoryWithFallback(productId);
        
        return ProductDetailResponse.builder()
            .productInfo(productInfo)
            .recommendations(recommendations)
            .inventory(inventory)
            .build();
    }
 
    /**
     * 推荐服务：带降级的调用
     * 
     * 降级策略：
     * - 熔断开启时：返回空的推荐列表
     * - 超时时：返回热门商品推荐（缓存）
     */
    @CircuitBreaker(name = "recommendationService", fallbackMethod = "fallbackRecommendations")
    public List<Recommendation> getRecommendations(String productId) {
        log.info("Fetching recommendations for product: {}", productId);
        return recommendationClient.getForProduct(productId);
    }
 
    /**
     * 推荐服务的降级方法
     */
    public List<Recommendation> fallbackRecommendations(String productId, Exception ex) {
        log.warn("Recommendation service unavailable for product={}, using fallback. Error={}", 
                 productId, ex.getMessage());
        
        // 降级策略A：返回空列表（最简单）
        if (ex instanceof CallNotPermittedException) {
            return Collections.emptyList();  // 熔断开启，直接返回空
        }
        
        // 降级策略B：返回缓存的通用推荐（基于品类）
        Category category = getProductCategory(productId);
        List<Recommendation> cached = cacheManager.getCache("recommendationCache")
            .get("category:" + category.getId(), List.class);
            
        return cached != null ? cached : getDefaultRecommendations();
    }
 
    /**
     * 库存服务：带降级的调用
     * 
     * 降级策略：
     * - 服务不可用时：显示"有货"（乐观估计，避免影响转化率）
     * - 响应慢时：显示缓存值（可能不是最新的）
     */
    @CircuitBreaker(name = "inventoryService", fallbackMethod = "fallbackInventory")
    public InventoryStatus getInventory(String productId) {
        log.info("Checking inventory for product: {}", productId);
        return inventoryClient.checkStock(productId);
    }
 
    /**
     * 库存服务的降级方法
     */
    public InventoryStatus fallbackInventory(String productId, Exception ex) {
        log.warn("Inventory service unavailable for product={}, using fallback", productId);
        
        // 尝试从Redis缓存获取（可能过期，但总比没有好）
        InventoryStatus cached = cacheManager.getCache("inventoryCache")
            .get("stock:" + productId, InventoryStatus.class);
            
        if (cached != null) {
            cached.setSource("CACHE");  # 标记来源是缓存
            return cached;
        }
        
        // 缓存也没有，返回默认值（显示"有货"，但标注不可靠）
        return InventoryStatus.builder()
            .productId(productId)
            .available(true)
            .quantity(-1)  // -1表示未知
            .source("DEFAULT_FALLBACK")
            .message("库存信息暂时不可用")
            .build();
    }
    
    // ... 其他辅助方法 ...
}

/**
 * Feature Flag管理的降级服务
 */
@Service
@RequiredArgsConstructor
@Slf4j
public class FeatureFlagDegradationService {
 
    private final FeatureFlagClient featureFlagClient;  # LaunchDarkly / Unleash / 自研
    private final CacheManager cacheManager;
 
    /**
     * 使用Feature Flag控制功能的启用/禁用
     */
    public <T> T executeWithFeatureFlag(
            String featureKey, 
            Supplier<T> enabledSupplier,
            Supplier<T> disabledSupplier,
            T defaultValue) {
        
        try:
            boolean isEnabled = featureFlagClient.isEnabled(featureKey, false);
            
            if (isEnabled) {
                log.debug("Feature '{}' is ENABLED, executing normal path", featureKey);
                return enabledSupplier.get();
            } else:
                log.info("Feature '{}' is DISABLED (degraded), executing fallback path", featureKey);
                return disabledSupplier.get();
                
        } catch (Exception e):
            log.error("Failed to evaluate feature flag '{}', using default value", featureKey, e);
            return defaultValue;
    }
}
 
/**
 * 在Controller中使用
 */
@RestController
@RequestMapping("/api/v1/products")
public class ProductControllerV1 {
 
    @Autowired
    private FeatureFlagDegradationService ffService;
 
    @GetMapping("/{productId}")
    public ResponseEntity<ProductDetailResponse> getProductDetail(
            @PathVariable String productId) {
        
        ProductDetailResponse response = ffService.executeWithFeatureFlag(
            "product.recommendation.enabled",  # Feature Key
            
            # 功能启用时的正常逻辑
            () -> {
                List<Recommendation> recs = recommendationService.get(productId);
                ProductDetail detail = productService.getWithRecommendations(productId, recs);
                return detail;
            },
            
            # 功能禁用时的降级逻辑（不调用推荐服务）
            () -> {
                ProductDetail detail = productService.getBasic(productId);
                detail.setRecommendations(Collections.emptyList());  # 空推荐列表
                detail.setDegradedFeatures(List.of("recommendation"));  # 标记哪些功能被降级了
                return detail;
            },
            
            # 默认值（Flag服务异常时）
            null  # 会走正常的完整逻辑
        );
        
        return ResponseEntity.ok(response);
    }
}

# istio-degradation.yaml
# 场景1：当检测到特定Header时，返回降级响应
apiVersion: networking.istio.io/v1beta1
kind: VirtualService
metadata:
  name: product-detail-service-vs
  namespace: production
spec:
  hosts:
  - product-detail-service
  http:
  - match:
    - headers:
        x-degradation-level:  # 自定义降级级别头
          exact: "heavy"  # 重度降级
    fault:
      abort:
        percentage:
          value: 100  # 100%的请求都返回降级响应
        httpStatus: 200
        body: '{"code":200,"data":{"recommendations":[],"inventory":{"available":true,"source":"DEGRADED"}}}'
        contentType: "application/json"
---
# 场景2：对特定用户的请求进行降级（灰度发布/金丝雀）
apiVersion: networking.istio.io/v1beta1
kind: VirtualService
metadata:
  name: user-specific-degradation
  namespace: production
spec:
  hosts:
  - order-service
  http:
  - match:
    - headers:
        x-user-tier:
          exact: "normal"  # 普通用户
    route:
    - destination:
        host: order-service
        subset: degraded  # 路由到降级版本的服务
  - match:
    - headers:
        x-user-tier:
          exact: "vip"  # VIP用户
    route:
    - destination:
        host: order-service
        subset: full  # VIP用户仍然使用全功能版本
---
# 定义降级版本的子集（可能是一个简化版的Deployment）
apiVersion: networking.istio.io/v1beta1
kind: DestinationRule
metadata:
  name: order-service-dr
  namespace: production
spec:
  host: order-service
  subsets:
  - name: full
    labels:
      version: v2.0  # 全功能版本
  - name: degraded
    labels:
      version: v1.0-degraded  # 降级版本（可能是旧代码或精简版）

/**
 * 多级降级策略枚举
 */
public enum DegradationLevel {
    NONE(0),           # 无降级，全量功能
    LIGHT(1),         # 轻度降级：关闭非关键特性
    MODERATE(2),      # 中度降级：简化数据、使用缓存
    HEAVY(3),         # 重度降级：仅核心功能
    EMERGENCY(4);      # 紧急模式：最小可用
 
    private final int level;
    DegradationLevel(int level) { this.level = level; }
    public int getLevel() { return level; }
}
 
/**
 * 统一的降级管理器
 */
@Service
@RequiredArgsConstructor
@Slf4g
public class DegradationManager {
 
    private final Map<String, DegradationStrategy> strategies;
    private final ApplicationEventPublisher eventPublisher;
 
    /**
     * 执行带有降级保护的操作
     */
    public <T> T executeWithDegradation(
            String operationName,
            DegradationLevel currentLevel,
            TriFunction<DegradationLevel, Supplier<T>, Supplier<T>, T> handler) {
        
        log.info("[Degradation] Executing '{}' at level: {}", operationName, currentLevel);
 
        switch (currentLevel) {
            case NONE:
                return handler.apply(DegradationLevel.NONE, 
                    this::normalExecution, 
                    this::lightDegradation);
                    
            case LIGHT:
                return handler.apply(DegradationLevel.LIGHT,
                    this::lightDegradation,
                    this::moderateDegradation);
                    
            case MODERATE:
                return handler.apply(DegradationLevel.MODERATE,
                    this::moderateDegradation,
                    this::heavyDegradation);
                    
            case HEAVY:
                return handler.apply(DegradationLevel.HEAVY,
                    this::heavyDegradation,
                    this::emergencyDegradation);
                    
            case EMERGENCY:
                return emergencyDegradation.get();
                
            default:
                throw new IllegalArgumentException("Unknown degradation level: " + currentLevel);
        }
    }
 
    /**
     * 发布降级事件（供监控和告警使用）
     */
    public void publishDegradationEvent(String service, DegradationLevel from, DegradationLevel to) {
        eventPublisher.publishEvent(new DegradationLevelChangedEvent(
            service, from, to, Instant.now()
        ));
        log.warn("[Degradation] Service '{}' degraded from {} to {}", service, from, to);
    }
}